package com.cloud.common.utils;

import com.fasterxml.jackson.core.JsonProcessingException;
import com.fasterxml.jackson.databind.ObjectMapper;
import org.modelmapper.ModelMapper;

import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.stream.Collectors;


/**
 * 对象映射工具类
 */
public class MappingUtil {

    private static final ObjectMapper objectMapper = new ObjectMapper();
    private static final ModelMapper modelMapper = new ModelMapper();

    /**
     * 对象转HashMap
     * @param object 对象
     * @return HashMap
     * @throws JsonProcessingException 转换异常
     */
    public static HashMap<String, Object> ObjectToMap(Object object) throws JsonProcessingException {
        String json = objectMapper.writeValueAsString(object);
        return objectMapper.readValue(json, HashMap.class);
    }

    /**
     * HashMap转对象
     * @param map HashMap
     * @param clazz 转换的目标对象
     * @return 对象
     * @param <T> 转换的目标类型
     * @throws JsonProcessingException 转换异常
     */
    public static <T> T MapToObject(Map<String, Object> map, Class<T> clazz) throws JsonProcessingException {
        String json = objectMapper.writeValueAsString(map);
        return objectMapper.readValue(json, clazz);
    }

    /**
     * json格式字符串转对象
     * @param json json格式字符串
     * @param clazz 目标对象
     * @return 对象
     * @param <T> 转换的目标类型
     * @throws JsonProcessingException 转换异常
     */
    public static <T> T JsonToObject(String json, Class<T> clazz) throws JsonProcessingException {
        return objectMapper.readValue(json, clazz);
    }

    /**
     * 对象转json格式字符串
     * @param object 对象
     * @return 字符串
     * @throws JsonProcessingException 转换异常
     */
    public static String ObjectToJson(Object object) throws JsonProcessingException {
        return objectMapper.writeValueAsString(object);
    }

    /**
     * 对象与对象之间进行映射
     * @param sourceObject 源对象
     * @param targetClazz 目标对象的类型
     * @return 转换后的目标对象
     * @param <T> 转换后的类型
     * @throws JsonProcessingException 转换异常
     */
    public static <T> T convertObject(Object sourceObject, Class<T> targetClazz) throws JsonProcessingException {
        String json = objectMapper.writeValueAsString(sourceObject);
        return objectMapper.readValue(json, targetClazz);
    }

    /**
     * 对象集合与对象集合之间进行映射
     * @param sourceObject 源对象
     * @param targetClazz 目标对象的类型
     * @return 转换后的目标对象
     * @param <T> 转换后的类型
     */
    public static <T,V> List<T>  convertObject(List<V> sourceObject, Class<T> targetClazz) {
        return sourceObject.stream()
                .map(breed -> modelMapper.map(breed, targetClazz))
                .collect(Collectors.toList());
    }

}
